<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Utilisation du port série en Java</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>port série</keywords>
        <author>Stéphane ARNAULT</author>
    </head>
    <body>
        <div class="chapter">
            <h2>Introduction</h2>
            <p>
                Dans cet article, je vais présenter comment utiliser le port série d'un micro-ordinateur dans le langage de programmation Java grâce
				à l'API (application programming interface) JavaComm.
                <br />
                Cette interface permet de développer des logiciels qui permettent de
				piloter un modem, un routeur ou tout autre composant qui se branche sur le port
				série/parallèle de votre ordinateur.
            </p>
            <p>Nous verrons dans un premier temps quelques généralités
				sur le port série, puis nous nous intéresserons au pré
				requis et à l'installation de l'API JavaComm avant de passer
				à la description des fonctions puis à la programmation Java.</p>
        </div>
        <div class="chapter">
            <h2>1. généralité sur le port série</h2>
            <p>
                <br />
                L'interface série est une interface asynchrone, ce qui signifie que le signal de cette interface n'est pas synchronisé avec celui d'un bus. Les
				bits des données sont envoyés les uns après les autres. Un caractère est généralement composé d'un ensemble de huit bits. Cette valeur est donc comprise entre 0 et
				255 (2 puissance 8) et elle est stockée sur 1 octet (c'est à dire 8 bits). Chaque caractère est délimité par un signal de début qui est un bit à 0 et par signal de
				fin standard qui peut correspondre à un ou deux bits de fin, cela permet d'indiquer que le caractère a bien été envoyé. L'interface asynchrone est orientée caractère,
				en effet on doit utiliser les signaux de début et de fin pour identifier un caractère. L'inconvénient de cette méthode est l’augmentation de la durée des transferts
				de presque 25 %. En effet pour chaque ligne de 8 bits il faut au minimum 2 bits.
				Le terme "série" viens juste du fait que les bits sont envoyés les uns après les autres sur un seul fil pour l'émission et un autre fil pour la réception, comme pour
				le téléphone. Il existe de nombreuse carte d'extension permettant d'avoir plusieurs ports séries ou port parallèle.
				Pour « transformer » les données à envoyer en suite de bit sérialisés, l’ordinateur utilise une petite puce, l’UART.
                <br />
            </p>
            <table width="70%" border="0" align="center" cellpadding="0" cellspacing="0">
                <tbody>
                    <tr>
                        <td>
                            <img src="./images/schema1.jpg" width="111" height="196" />
                        </td>
                        <td>
                            Connecteur DB9
                            <br />
                            1 - DCD, Data Carrier Detect
                            <br />
                            2 - TxD, Transmission du signal
                            <br />
                            3 - ExD, Réception du signal
                            <br />
                            4 - DTR, Data Terminal Ready
                            <br />
                            5 - GND, Masse électrique
                            <br />
                            6 - DSR, Data Set Ready
                            <br />
                            7 - CTS, Clear To Send
                            <br />
                            8 - RTS, Request To Send
                            <br />
                            9 - RI, Ring Indicator
                        </td>
                    </tr>
                </tbody>
            </table>
            <p align="center">
                <em>Schema d'un port série</em>
            </p>
            <p>
                <br />
                Dans cet article, nous ne verrons pas le fonctionnement physique du port série
				(correspondance des broches, fonctionnement de la puce UART) car la partie physique
				est totalement transparente pour le programmeur.
                <br />
            </p>
        </div>
        <div class="chapter">
            <h2>2. Installation</h2>
            <div class="subChapter">
                <h3>2.1. Pré Requis</h3>
                <p>Plusieurs pré requis sont nécessaires afin d'utiliser le port série dans un programme Java.</p>
                <p>
                    • Tout d’abord, un port série doit être présent sur le micro-ordinateur, il servira à transmettre les données.
                    <br />
                    • Il faut un compilateur Java disponible sur le site officiel de Sun http://java.sun.com qui permet de générer le byte code à partir du code source en java.
                    <br />
                    • Il faut avoir téléchargé et installé la « Java Communications API », cette étape sera détaillée dans la partie 4 de cet article.
                    <br />
                    • Une machine virtuelle est nécessaire pour exécuter le
					programme.
                </p>
                <p>Lorsque tous ces impératifs sont faits, on peut enfin passer à
					la programmation permettant le contrôle du port série.</p>
                <h3>2.2. Installations</h3>
                <p>L’installation de l’API JavaComm n’étant pas évidente pour beaucoup de programmeurs, j’ai préféré détailler pas à pas la marche à suivre.
					Le package JavaComm est disponible sur le site officiel de Sun à l’adresse suivante : http://java.sun.com/products/javacomm/ . Il faut dans un premier temps
					télécharger la version la plus récente qui correspond à votre plateforme de développement. Les exemples que nous verrons dans cet article seront adaptés aux
					systèmes d’exploitation de Windows mais la marche à suivre est la même pour Solaris ou Linux par exemple. Il n’existe malheureusement pas de version pour MacOs.</p>
                <p>Pour placer les fichiers nécessaires à l’installation de JavaComm, nous allons supposer que le JDK est installé dans le répertoire c:\java et la machine virtuelle
					dans le répertoire c:\java\jre\, vous devez modifier les chemins qui suivent en fonction de votre configuration.
					Vous devez vérifier que :</p>
                • Le fichier win32com.dll est bien dans c:\java\bin.
                <br />
                • Le fichier comm.jar est bien dans c:\java\lib et c:\java\jre\lib\ext.
                <br />
                • Le fichier javax.comm.properties est bien dans c:\java\lib.
                <br />
                Tous ces fichiers sont contenus dans l’archive que vous avez téléchargé précédemment.
				Pour compiler, il faut que le fichier comm.jar soit dans le répertoire c:\java\jre\lib\ext.
				Il faut aussi définir une nouvelle variable d'environnement pour référencer les classes du package comm.jar :
                <br />
                set CLASSPATH=%classpath%;c:\java\lib\comm.jar;.
                <br />
                Il faut absolument que le package JAVACOMM soit placé sur le même disque logique qui contient le JDK pour que le programme fonctionne.
                <br />
                C'est à dire que le fichier .class de votre exécutable doit se trouver sur le disque C si le JDK est dans le répertoire c:\\Java.
                <br />
                Maintenant que tout est installé, on peut aborder le fonctionnement de l’API.
                <br />
            </div>
            <h2>3. l’api de communication en Java</h2>
            <div class="subChapter">
                <h3>3.1. Théorie</h3>
                <p>
                    L’API JavaComm (Java communications API) que nous avons installé précédemment permet de gérer les communications par le port série (RS232) ou par
					le port parallèle (IEEE 1284) de manière simplifiée et indépendamment de la plate forme utilisée.
                    <br />
                    La documentation en anglais sur les classes du package se trouve sur
                    <br />
                    http://java.sun.com/products/javacomm/javadocs/API_users_guide.html
                </p>
                <p>Cette API ajoute une couche native qui fait l’interface entre le matériel et le logiciel java, comme le montre le schéma ci-dessous.</p>
                <p align="center">
                    <img src="./images/schema2.jpg" width="355" height="300" />
                    <br />
                </p>
                <p>
                    Grâce à cet API il n'est pas nécessaire de se soucier
					du matériel, les transferts sont automatiquement gérés.
                    <br />
                    La communication par le port série ce fait par un flot de donnée.
					Il faut donc commencer par définir un BufferedReader et un PrintWriter
					qui vont servir à envoyer et recevoir les données, puis instancier
					un CommPortIdentifier qui défini le port à utiliser et un SerialPort
					qui gère la connexion série. Les paramètres de la connexion série
					sont définis gràce à la méthode setSerialPortParams de la classe
					SerialPort.
                    <br />
                    Nous allons mettre en pratique cette description succincte de l'API dans
					la partie suivante de cet article afin de mieux comprendre son fonctionnement.
                </p>
                <h3>3.2. Mise en pratique</h3>
                Afin d'éclaircir les informations théoriques que nous avons vues précédemment
				sur le fonctionnement de l'API JavaComm, nous allons maintenant voir un
				exemple concret d'utilisation avec un programme complet qui ouvre une connexion
				sur le port Com1 et qui envoie une chaîne de caractère.
                <br />
            </div>
            <textarea name="code" class="java" rows="50" cols="50">import javax.comm.*;
				import java.io.*;
				import java.util.*;
				/*
				Cette classe permet de tester les ports séries disponibles
				en les listant puis en créant un stream d'entrée et de sortie
				*/
				public class TesteJavaComm
				{
				CommPortIdentifier portId;
				BufferedReader in;
				PrintWriter out;
				SerialPort serialPort;
				/*
				Constructeur de la classe TesteJavaComm qui prend en paramètre le port série à utiliser.
				Dans un premier temps on liste les ports disponibles sur le pc
				*/
				public TesteJavaComm (String com)
				{
				System.out.println("listage des ports série disponibles:");
				listePortsDispo();
				try
				{
				//ouverture du port série:
				portId=CommPortIdentifier.getPortIdentifier(com);
				serialPort=(SerialPort)portId.open("Envoi",2000);
				//on sélectionne tous les paramètres de la connexion série:
				serialPort.setSerialPortParams(9600,SerialPort.DATABITS_8,
				SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
				System.out.println("Ouverture du port "+com);
				//pour lire et écrire avec des streams:
				in=new BufferedReader(
				new InputStreamReader(serialPort.getInputStream()));
				out=new PrintWriter(serialPort.getOutputStream());
				//Teste de lecture/ecriture sur le port série
				String originalText="une chaine de caractere";
				outputArray = originalText.getBytes( );
				out.write ( outputArray, 0 , length );
				int b = in.read()
				in.close();
				out.close();
				}
				catch (Exception e)
				{
				e.printStackTrace();
				}
				}//fin constructeur
				public void listePortsDispo()
				{
				System.err.println("recherche...");
				Enumeration portList=CommPortIdentifier.getPortIdentifiers();
				if (portList==null)
				{
				System.err.println("Aucun port de communication détecté");
				return;
				}
				while (portList.hasMoreElements())
				{
				portId=(CommPortIdentifier)portList.nextElement();
				System.out.println("* "+portId.getName());
				} // while
				} //fin de la methode listePortsDispo()
				/*
				Methode main qui permet de tester notre classe de teste en ouvrant une connexion sur le port COM1.
				*/
				public static void main(String args[])
				{
				new TesteJavaComm ("COM1");
				}//fin du main
				}//fin de la classe</textarea>
            <h2>Conclusion</h2>
            <p>
                Nous avons vu comment communiquer avec le port série en programmation
				Java.
                <br />
                L'API que nous avons utilisée dans cet exemple permet aussi la communication
				par le port parallèle avec un fonctionnement à peu près
				similaire.
                <br />
                Il reste que cet API a un avenir incertain. Malgré le portage sous linux dernièrement, il n'éxiste toujours pas
				de portage officiel de cet API MacOs qui représentent pourtant
				une part de marché non négligeable.
                <br />
                De plus, les ports USB sont devenue un standard depuis quelques années ce qui a totalement engloutie le port série.
				Ce dernier étant utilisé dans de rares applications professionnels
            </p>
        </div>
    </body>
</html>

